// index.js - 排版读取工具逻辑

// 创建API请求实例
const api = axios.create({
    baseURL: '/', // 根据实际情况设置后端API的基础路径
    timeout: 60000,  // 请求超时时间
    headers: {
        'Content-Type': 'application/json'
    }
});

// 添加请求拦截器
api.interceptors.request.use(
    config => {
        // 可以在这里添加认证信息等
        return config;
    },
    error => {
        return Promise.reject(error);
    }
);

// 添加响应拦截器
api.interceptors.response.use(
    response => {
        // 2xx 范围内的状态码触发该函数
        const responseData = response.data;
        if ('data' in responseData) {
            return responseData.data;
        }

        return response.data;
    },
    error => {
        // 超出 2xx 范围的状态码触发该函数
        let errorMessage = '网络请求失败';
        if (error.response) {
            // 服务器返回了错误状态码
            switch (error.response.status) {
                case 400:
                    errorMessage = '请求错误';
                    break;
                case 401:
                    errorMessage = '未授权访问';
                    break;
                case 403:
                    errorMessage = '禁止访问';
                    break;
                case 404:
                    errorMessage = '请求的资源不存在';
                    break;
                case 500:
                    errorMessage = '服务器内部错误';
                    break;
                default:
                    errorMessage = `请求错误 (${error.response.status})`;
            }
        } else if (error.request) {
            // 请求发出但没有收到响应
            errorMessage = '服务器无响应';
        }
        // alert(errorMessage);
        return Promise.reject(error);
    }
);

// API服务方法
const apiService = {
    // 获取数据库配置
    getDatabaseConfig() {
        return api.get('/getDatabaseConfig');
    },
    // 测试数据库连接
    testDatabaseConnection(config) {
        return api.post('/configDatabase', config);
    },

    // 保存数据库配置
    //   saveDatabaseConfig(config) {
    //     return api.post('/configDatabase', config);
    //   },
    // 获取共享目录配置
    getShareConfig() {
        return api.get('/getShareDirConfig');
    },
    // 测试共享目录
    testSharePath(config) {
        return api.post('/configShareDir', config);
    },

    // 保存共享目录配置
    //   saveShareConfig(config) {
    //     return api.post('/configShareDir', config);
    //   },

    // 查询排版基本信息
    queryBasicInfo(config) {
        return api.post('/search', config);
    },
    // 清除历史数据
    clearHistoryData() {
        return api.post('/removeSearchData', {});
    },
    saveBasicInfo(items) {
        return api.post('/updateSearchData', items);
    },

    // 读取排版打印信息
    // readPrintInfo(basicInfoId) {
    // return api.get(`/typesetting/printInfo/${basicInfoId}`);
    // },

    // 保存基本信息
    //   saveBasicInfo(data) {
    //     return api.post('/typesetting/basicInfo', data);
    //   },

    // 导出Excel
    exportExcel(basicInfoIds) {
        return api.post(`/export`, basicInfoIds, {
            responseType: 'blob'
        });
    }
};

// Vue实例
new Vue({
    el: "#app",
    data: {
        dbConfig: {
            ip: "",
            port: 1433,
            database: "",
            username: "",
            password: "",
            _testStatus: false  // 测试状态字段整合到配置对象中
        },
        // 临时变量存储当前编辑和测试的数据库配置
        tempDbConfig: {
            ip: "",
            port: 1433,
            database: "",
            username: "",
            password: "",
            _testStatus: false
        },
        errors: {
            ip: "",
            port: "",
            database: "",
            username: "",
            password: "",
            shareIp: "",
            shareUsername: "",
            sharePassword: "",
        },
        shareConfig: {
            ip: "",
            username: "",
            password: "",
            _testStatus: false  // 测试状态字段整合到配置对象中
        },
        // 临时变量存储当前编辑和测试的共享文件夹配置
        tempShareConfig: {
            ip: "",
            username: "",
            password: "",
            _testStatus: false
        },
        queryParams: {
            partNo: "", // 零件编号
            machineName: "", // 基准机床名称
            materialCode: "", // 材料代码
            startUpdateTime: "",
            endUpdateTime: ""
        },
        basicInfoData: [],
        selectedBasicInfo: null,
        selectedItems: [], // 新增存储多选数据的数组
        showModal: false,
        modalType: null, // 'dbConfig', 'shareConfig', 'confirm'
        confirmMessage: "",
        confirmCallback: null,
        loading: false, // 加载状态
        // 添加编辑单元格相关数据
        editingCell: {
            item: null,
            field: null,
            value: null,
            oldValue: null
        },
        // 存储编辑后的item数据列表（用于提交给服务端）
        editedItems: [],
        // 表格配置
        tableConfig: [
            {
                field: 'selected',
                type: 'checkbox',
                label: '选择',
                width: 80,
                editable: false,
                textAlign: 'center',
                overflow: false,
                fixed: 'left'
            },
            {
                field: 'f1',
                type: 'text',
                label: '产品代码',
                width: 120,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f2',
                type: 'text',
                label: '套件代码',
                width: 120,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f3',
                type: 'text',
                label: '零件编号',
                width: 150,
                editable: false,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f4',
                type: 'text',
                label: '设备名称',
                width: 200,
                editable: false,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f5',
                type: 'text',
                label: '基准机床名称',
                width: 150,
                editable: false,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f6',
                type: 'text',
                label: '材料代码',
                width: 120,
                editable: false,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f7',
                type: 'number',
                label: '排版零件总数',
                width: 140,
                editable: false,
                textAlign: 'center',
                overflow: false
            },
            {
                field: 'f8',
                type: 'number',
                label: '制造数量',
                width: 100,
                editable: true,
                textAlign: 'center',
                overflow: false
            },
            {
                field: 'f9',
                type: 'text',
                label: '登记目标调度分类',
                width: 180,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f10',
                type: 'text',
                label: '堆叠托盘编号',
                width: 150,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f11',
                type: 'text',
                label: '主架托盘编号',
                width: 150,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f12',
                type: 'text',
                label: '主架托盘更换标志',
                width: 160,
                editable: true,
                textAlign: 'center',
                overflow: false
            },
            {
                field: 'f13',
                type: 'text',
                label: '堆叠方向',
                width: 100,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f14',
                type: 'text',
                label: '外围装置-1',
                width: 120,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f15',
                type: 'text',
                label: '外围装置-2',
                width: 120,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f16',
                type: 'text',
                label: '外围装置-3',
                width: 120,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f17',
                type: 'text',
                label: '卸载超驰',
                width: 100,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f18',
                type: 'text',
                label: '有无分离',
                width: 100,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f19',
                type: 'text',
                label: '分离时间',
                width: 100,
                editable: true,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f20',
                type: 'text',
                label: '排版切割文件',
                width: 200,
                editable: false,
                textAlign: 'center',
                overflow: true
            },
            {
                field: 'f21',
                type: 'text',
                label: '最近更新时间',
                width: 180,
                editable: false,
                textAlign: 'center',
                overflow: true,
                fixed: 'right'
            }
        ],
        // 保存原始零件总数值的字典
        originalPartsTotalValues: {}
    },
    created() {
        // 加载本地存储的配置
        this.loadLocalConfigs();
        
        // 不再初始化时自动加载服务器配置，改为在弹窗打开时加载
        // this.loadServerConfigs();
    },
    // 添加计算属性
    computed: {
        // 通过计算属性自动获取所有选中项的childs数据
        printInfoData() {
            let allChilds = [];
            this.selectedItems.forEach(item => {
                if (item.childs && Array.isArray(item.childs)) {
                    allChilds = allChilds.concat(item.childs);
                }
            });
            return allChilds;
        }
    },
    // 添加自定义指令 - 用于自动聚焦到编辑输入框
    directives: {
        focus: {
            inserted: function (el) {
                el.focus();
            }
        }
    },
    methods: {
        loadLocalConfigs() {
            // 从localStorage加载配置
            const savedDbConfig = localStorage.getItem("dbConfig");
            const savedShareConfig = localStorage.getItem("shareConfig");

            if (savedDbConfig) {
                this.dbConfig = JSON.parse(savedDbConfig);
                // 确保_testStatus字段存在
                if (this.dbConfig._testStatus === undefined) {
                    this.dbConfig._testStatus = false;
                }
            }

            if (savedShareConfig) {
                this.shareConfig = JSON.parse(savedShareConfig);
                // 确保_testStatus字段存在
                if (this.shareConfig._testStatus === undefined) {
                    this.shareConfig._testStatus = false;
                }
            }
        },
        // 分别加载数据库和共享目录配置
        loadDbConfig() {
            this.loading = true;
            
            apiService.getDatabaseConfig()
                .then(response => {
                    if (response) {
                        // 更新数据库配置
                        this.tempDbConfig = {
                            ...response,
                            _testStatus: true // 假设从服务器返回的配置是可用的
                        };
                    } else {
                        // 如果服务器无数据，使用本地缓存的配置
                        this.tempDbConfig = JSON.parse(JSON.stringify(this.dbConfig));
                    }
                })
                .catch(error => {
                    console.error("获取数据库配置失败:", error);
                    // 发生错误时使用本地缓存的配置
                    this.tempDbConfig = JSON.parse(JSON.stringify(this.dbConfig));
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        
        loadShareConfig() {
            this.loading = true;
            
            apiService.getShareConfig()
                .then(response => {
                    if (response) {
                        // 更新共享目录配置
                        this.tempShareConfig = {
                            ...response,
                            _testStatus: true // 假设从服务器返回的配置是可用的
                        };
                    } else {
                        // 如果服务器无数据，使用本地缓存的配置
                        this.tempShareConfig = JSON.parse(JSON.stringify(this.shareConfig));
                    }
                })
                .catch(error => {
                    console.error("获取共享目录配置失败:", error);
                    // 发生错误时使用本地缓存的配置
                    this.tempShareConfig = JSON.parse(JSON.stringify(this.shareConfig));
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        
        // 此方法保留但不再自动调用，改为在需要时调用loadDbConfig和loadShareConfig
        loadServerConfigs() {
            // 从服务器加载数据库配置和共享配置（同时进行）
            this.loading = true;
            
            // 创建两个Promise，同时执行不依赖顺序
            const dbConfigPromise = apiService.getDatabaseConfig()
                .then(response => {
                    if (response) {
                        // 更新数据库配置
                        this.dbConfig = {
                            ...response,
                            _testStatus: true // 假设从服务器返回的配置是可用的
                        };
                        // 同步更新tempDbConfig
                        this.tempDbConfig = JSON.parse(JSON.stringify(this.dbConfig));
                        // 保存到本地存储
                        localStorage.setItem("dbConfig", JSON.stringify(this.dbConfig));
                    }
                })
                .catch(error => {
                    console.error("获取数据库配置失败:", error);
                });
                
            const shareConfigPromise = apiService.getShareConfig()
                .then(response => {
                    if (response) {
                        // 更新共享目录配置
                        this.shareConfig = {
                            ...response,
                            _testStatus: true // 假设从服务器返回的配置是可用的
                        };
                        // 同步更新tempShareConfig
                        this.tempShareConfig = JSON.parse(JSON.stringify(this.shareConfig));
                        // 保存到本地存储
                        localStorage.setItem("shareConfig", JSON.stringify(this.shareConfig));
                    }
                })
                .catch(error => {
                    console.error("获取共享目录配置失败:", error);
                });
                
            // 等待两个配置都完成后关闭加载状态
            Promise.all([dbConfigPromise, shareConfigPromise])
                .finally(() => {
                    this.loading = false;
                });
        },
        showDbConfigModal() {
            // 打开弹窗前，从服务器获取最新的数据库配置
            this.loadDbConfig();
            this.modalType = 'dbConfig';
            this.showModal = true;
        },
        showShareConfigModal() {
            // 打开弹窗前，从服务器获取最新的共享目录配置
            this.loadShareConfig();
            this.modalType = 'shareConfig';
            this.showModal = true;
        },
        closeModal() {
            // 关闭modal时清空临时变量
            this.showModal = false;
            this.modalType = null;
            this.confirmCallback = null;
        },
        checkConfigBeforeQuery() {
            // 检查数据库配置和测试状态
            if (!this.dbConfig._testStatus) {
                this.confirmMessage = "数据库配置未完成，是否现在配置？";
                this.modalType = 'confirm';
                this.showModal = true;
                this.confirmCallback = this.showDbConfigModal;
                return;
            }

            // 检查共享目录配置和测试状态
            if (!this.shareConfig._testStatus) {
                this.confirmMessage = "共享目录配置未完成，是否现在配置？";
                this.modalType = 'confirm';
                this.showModal = true;
                this.confirmCallback = this.showShareConfigModal;
                return;
            }

            // 所有配置都已测试通过，执行查询
            this.queryBasicInfo();
        },
        confirmAction() {
            const callback = this.confirmCallback;
            this.closeModal();
            if (callback) {
                callback();
            }
        },
        isDbConfigValid() {
            // 检查临时数据库配置是否完整
            return this.tempDbConfig.ip &&
                this.tempDbConfig.port &&
                this.tempDbConfig.database &&
                this.tempDbConfig.username &&
                this.tempDbConfig.password;
        },
        isShareConfigValid() {
            // 检查临时共享目录配置是否完整
            return this.tempShareConfig.ip && this.tempShareConfig.ip.trim() !== '' &&
                this.tempShareConfig.username && this.tempShareConfig.username.trim() !== '' &&
                this.tempShareConfig.password && this.tempShareConfig.password.trim() !== '';
        },
        testDatabaseConnection() {
            // 先进行全部字段的验证
            this.validateIpField();
            this.validatePortField();
            this.validateDatabaseField();
            this.validateUsernameField();
            this.validatePasswordField();

            // 如果有验证错误，则不继续测试连接
            if (this.hasErrors()) {
                return;
            }

            // 设置加载状态
            this.loading = true;

            // 测试数据库连接
            apiService.testDatabaseConnection(this.tempDbConfig)
                .then(response => {
                    if (response) {
                        alert("数据库连接成功！");
                        // 更新临时变量的测试状态
                        this.tempDbConfig._testStatus = true;
                    } else {
                        alert("数据库连接失败！");
                        this.tempDbConfig._testStatus = false;
                    }
                })
                .catch(error => {
                    console.error("数据库连接测试失败:", error);
                    alert("数据库连接失败！");
                    this.tempDbConfig._testStatus = false;
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        saveDatabaseConfig() {
            // 先进行全部字段的验证
            this.validateIpField();
            this.validatePortField();
            this.validateDatabaseField();
            this.validateUsernameField();
            this.validatePasswordField();

            // 如果有验证错误，则不继续保存
            if (this.hasErrors()) {
                return;
            }

            // 如果临时配置未测试通过，则不允许保存
            if (!this.tempDbConfig._testStatus) {
                alert("请先测试连接成功后再保存配置！");
                return;
            }

            // 将临时配置保存到主配置
            this.dbConfig = JSON.parse(JSON.stringify(this.tempDbConfig));

            // 保存到本地存储
            localStorage.setItem("dbConfig", JSON.stringify(this.dbConfig));
            alert("数据库配置已保存成功！");
            this.closeModal();

            // 如果配置是由于查询触发的，检查是否需要继续配置共享目录
            this.checkConfigAfterSave();
        },
        checkConfigAfterSave() {
            if (!this.shareConfig._testStatus) {
                this.confirmMessage = "共享目录配置未完成，是否现在配置？";
                this.modalType = 'confirm';
                this.showModal = true;
                this.confirmCallback = this.showShareConfigModal;
            }
        },
        validateIpField() {
            const ipPattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^localhost$/;

            if (!this.tempDbConfig.ip) {
                this.errors.ip = "IP地址不能为空";
            } else if (!ipPattern.test(this.tempDbConfig.ip) && this.tempDbConfig.ip !== "localhost") {
                this.errors.ip = "请输入有效的IP地址格式或localhost";
            } else {
                this.errors.ip = "";
            }
        },
        validatePortField() {
            if (!this.tempDbConfig.port) {
                this.errors.port = "端口号不能为空";
            } else if (isNaN(this.tempDbConfig.port) || this.tempDbConfig.port < 1 || this.tempDbConfig.port > 65535) {
                this.errors.port = "端口号必须在1-65535之间";
            } else {
                this.errors.port = "";
            }
        },
        validateDatabaseField() {
            if (!this.tempDbConfig.database) {
                this.errors.database = "数据库名称不能为空";
            } else {
                this.errors.database = "";
            }
        },
        validateUsernameField() {
            if (!this.tempDbConfig.username) {
                this.errors.username = "用户名不能为空";
            } else {
                this.errors.username = "";
            }
        },
        validatePasswordField() {
            if (!this.tempDbConfig.password) {
                this.errors.password = "密码不能为空";
            } else {
                this.errors.password = "";
            }
        },
        hasErrors() {
            return this.errors.ip || this.errors.port || this.errors.database ||
                this.errors.username || this.errors.password || this.errors.shareIp ||
                this.errors.shareUsername || this.errors.sharePassword;
        },
        validateDateRange() {
            // 如果两个日期都填了，检查开始日期是否大于结束日期
            if (this.queryParams.startUpdateTime && this.queryParams.endUpdateTime) {
                const startDate = new Date(this.queryParams.startUpdateTime);
                const endDate = new Date(this.queryParams.endUpdateTime);

                if (startDate > endDate) {
                    alert("开始日期不能大于结束日期");
                    return false;
                }
            }

            return true;
        },
        validateShareIpField() {
            if (!this.tempShareConfig.ip.trim()) {
                this.errors.shareIp = "共享IP地址不能为空";
            } else {
                this.errors.shareIp = "";
            }
        },
        validateShareUsernameField() {
            if (!this.tempShareConfig.username.trim()) {
                this.errors.shareUsername = "用户名不能为空";
            } else {
                this.errors.shareUsername = "";
            }
        },
        validateSharePasswordField() {
            if (!this.tempShareConfig.password.trim()) {
                this.errors.sharePassword = "密码不能为空";
            } else {
                this.errors.sharePassword = "";
            }
        },
        testSharePath() {
            // 测试共享路径
            this.validateShareIpField();
            this.validateShareUsernameField();
            this.validateSharePasswordField();

            if (this.hasErrors()) {
                return;
            }

            // 设置加载状态
            this.loading = true;

            apiService.testSharePath(this.tempShareConfig)
                .then(response => {
                    if (response) {
                        alert("共享目录连接成功！");
                        // 更新临时变量的测试状态
                        this.tempShareConfig._testStatus = true;
                    } else {
                        alert("共享目录连接失败！");
                        this.tempShareConfig._testStatus = false;
                    }
                })
                .catch(error => {
                    console.error("测试共享目录失败:", error);
                    alert("共享目录连接失败！");
                    this.tempShareConfig._testStatus = false;
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        saveShareConfig() {
            // 保存共享路径配置
            this.validateShareIpField();
            this.validateShareUsernameField();
            this.validateSharePasswordField();

            if (this.hasErrors()) {
                return;
            }

            // 如果临时配置未测试通过，则不允许保存
            if (!this.tempShareConfig._testStatus) {
                alert("请先测试连接成功后再保存配置！");
                return;
            }

            // 将临时配置保存到主配置
            this.shareConfig = JSON.parse(JSON.stringify(this.tempShareConfig));

            // 保存到本地存储
            localStorage.setItem("shareConfig", JSON.stringify(this.shareConfig));
            alert("共享目录配置保存成功！");
            this.closeModal();
        },
        queryBasicInfo() {
            // 查询前确保配置测试已通过
            if (!this.dbConfig._testStatus || !this.shareConfig._testStatus) {
                this.checkConfigBeforeQuery();
                return;
            }

            // 验证搜索条件，至少有一个不为空
            if (!this.queryParams.partNo && 
                !this.queryParams.machineName && 
                !this.queryParams.materialCode && 
                !this.queryParams.startUpdateTime && 
                !this.queryParams.endUpdateTime) {
                alert("请至少填写一个搜索条件");
                return;
            }

            // 验证日期范围
            if (!this.validateDateRange()) {
                return;
            }

            // 查询基本信息
            console.log("查询条件:", this.queryParams);

            // 设置加载状态
            this.loading = true;

            // 调用API查询
            apiService.queryBasicInfo(this.queryParams)
                .then(response => {
                    // 检查是否返回历史数据
                    if (response.historyData) {
                        this.loading = false;
                        // 弹出确认框询问用户是否清除历史数据
                        if (confirm("已存在上次查询数据，是否清除？")) {
                            // 用户选择"是"，清除历史数据
                            this.loading = true;
                            apiService.clearHistoryData()
                                .then(() => {
                                    // 清除成功后不渲染数据
                                    this.basicInfoData = [];
                                    this.selectedItems = [];
                                    this.selectedBasicInfo = null;
                                })
                                .catch(error => {
                                    console.error("清除历史数据失败:", error);
                                })
                                .finally(() => {
                                    this.loading = false;
                                });
                        } else {
                            // 用户选择"否"，渲染历史数据
                            this.renderQueryResults(response.data || []);
                        }
                    } else {
                        // 没有历史数据，直接渲染结果
                        this.renderQueryResults(response.data || []);
                    }
                })
                .catch(error => {
                    console.error("查询基本信息失败:", error);
                    this.basicInfoData = [];
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        // 渲染查询结果
        renderQueryResults(data) {
            // 清空原始值存储
            this.originalPartsTotalValues = {};
            
            this.basicInfoData = data.map(item => {
                // 创建新对象，添加selected属性
                const newItem = { ...item, selected: false };
                
                // 保存原始零件总数值 - 注释掉零件总数显隐相关逻辑
                /*if (item.serialNumber) {
                    this.originalPartsTotalValues[item.serialNumber] = item.f7;
                }
                
                // 将显示值置空
                newItem.f7 = '';*/
                
                return newItem;
            });
            
            if (this.basicInfoData.length === 0) {
                alert("未查询到符合条件的数据");
            }
        },
        resetQuery() {
            // 重置查询条件
            this.queryParams = {
                partNo: "", // 零件编号
                machineName: "", // 基准机床名称
                materialCode: "", // 材料代码
                startUpdateTime: "",
                endUpdateTime: ""
            };

            // 重置数据和选择状态
            this.basicInfoData.forEach(item => {
                item.selected = false;
                // 清空排版零件总数值 - 注释掉零件总数显隐相关逻辑
                //item.f7 = '';
            });
            this.basicInfoData = [];
            this.selectedBasicInfo = null;
            this.selectedItems = []; // 清空选中项目

            // 清空编辑状态
            this.clearEditedItems();
        },
        selectBasicInfo(item) {
            // 选择基本信息记录
            this.selectedBasicInfo = item;
        },
        // 保留readPrintInfo方法的空实现，以防其他地方还有调用
        readPrintInfo() {
            // 不再需要手动读取，计算属性会自动更新
            console.log("不再需要手动读取打印信息，已通过计算属性自动更新");
        },
        saveBasicInfo() {
            // 保存基本信息
            if (this.editedItems.length === 0) return;

            // 设置加载状态
            this.loading = true;

            // 构造包含历史数据状态的完整数据对象
            const dataToSave = {
                historyData: true,
                data: this.basicInfoData  // 发送完整数据，包括未编辑的项
            };

            // 调用API保存数据
            apiService.saveBasicInfo(dataToSave)
                .then(() => {
                    alert("基本信息保存成功！");
                    // 保存成功后清空编辑状态，但保留数据
                    this.clearEditedItems();
                })
                .catch(error => {
                    alert("部分或全部基本信息保存失败");
                    console.error("保存基本信息失败:", error);
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        exportExcel() {
            // 导出Excel
            if (this.printInfoData.length === 0) return;

            // 设置加载状态
            this.loading = true;

            // 收集所有选中项的serialNumber
            const serialNumbers = this.selectedItems.map(item => item.serialNumber);

            // 调用API导出Excel，传入serialNumber列表
            apiService.exportExcel(serialNumbers)
                .then(response => {
                    // 创建Blob对象
                    const blob = new Blob([response], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });

                    // 创建下载链接
                    const url = window.URL.createObjectURL(blob);
                    const a = document.createElement('a');
                    a.href = url;
                    a.download = `排版信息_${new Date().getTime()}.xlsx`;
                    document.body.appendChild(a);
                    a.click();

                    // 清理
                    window.URL.revokeObjectURL(url);
                    document.body.removeChild(a);
                })
                .catch(error => {
                    console.error("导出Excel失败:", error);
                    alert("导出Excel失败");
                })
                .finally(() => {
                    this.loading = false;
                });
        },
        toggleSelection(item) {
            // 根据item.selected状态更新selectedItems
            if (item.selected) {
                // 添加到selectedItems（如果不存在）
                if (!this.selectedItems.includes(item)) {
                    this.selectedItems.push(item);
                    // 如果是第一个选中的项目，设置为selectedBasicInfo
                    if (this.selectedItems.length === 1) {
                        this.selectedBasicInfo = item;
                    }
                }
            } else {
                // 从selectedItems中移除
                const index = this.selectedItems.findIndex(selected => selected.serialNumber === item.serialNumber);
                if (index !== -1) {
                    this.selectedItems.splice(index, 1);
                    // 更新selectedBasicInfo（如果需要）
                    if (this.selectedBasicInfo && this.selectedBasicInfo.serialNumber === item.serialNumber) {
                        this.selectedBasicInfo = this.selectedItems.length > 0 ? this.selectedItems[0] : null;
                    }
                }
            }
        },

        isDataComplete(item) {
            // 检查所有可编辑字段是否有值
            const editableFields = this.tableConfig
                .filter(col => col.editable && col.field !== 'selected')
                .map(col => col.field);

            // 排版零件总数和主架托盘编号允许为空
            const allowEmptyFields = ['f7', 'f11'];

            // 检查每个可编辑字段是否有值
            for (const field of editableFields) {
                // 如果字段在允许为空的列表中，跳过检查
                if (allowEmptyFields.includes(field)) {
                    continue;
                }
                
                // 对于文本字段，检查是否有值且不为空白字符串
                if (typeof item[field] === 'string' && item[field].trim() === '') {
                    return false;
                }
                // 对于数字字段，检查是否为数字且不为0或NaN
                else if (typeof item[field] === 'number' && (isNaN(item[field]) || item[field] === 0)) {
                    return false;
                }
                // 检查字段是否存在且有值
                else if (item[field] === undefined || item[field] === null || item[field] === '') {
                    return false;
                }
            }

            // 必填的非可编辑字段检查，排版零件总数(f7)允许为空
            return item.f3 && item.f3.trim() !== '' &&
                item.f4 && item.f4.trim() !== '' &&
                item.f5 && item.f5.trim() !== '' &&
                item.f6 && item.f6.trim() !== '';
        },

        // 处理复选框点击
        handleCheckboxClick(event, item) {
            // 检查当前行是否有未保存的编辑
            const isCurrentItemEdited = this.editedItems.some(editedItem =>
                editedItem.serialNumber === item.serialNumber
            );

            if (isCurrentItemEdited) {
                // 阻止默认行为（阻止复选框状态变化）
                event.preventDefault();
                alert("当前行有未保存的编辑内容，请先保存后再选择！");
                return;
            }

            // 检查数据完整性
            if (!this.isDataComplete(item)) {
                // 阻止默认行为（阻止复选框状态变化）
                event.preventDefault();
                alert("数据不完整，不允许选中，请维护！");
                return;
            }

            // 手动切换选中状态
            item.selected = !item.selected;

            // 更新selectedItems集合
            this.toggleSelection(item);
        },

        // 进入单元格编辑模式
        editCell(item, field, event) {
            // 如果已经在编辑，先保存之前的编辑
            if (this.editingCell.item && (this.editingCell.item !== item || this.editingCell.field !== field)) {
                this.saveEdit();
            }

            // 设置当前编辑的单元格
            this.editingCell = {
                item: item,
                field: field,
                value: item[field],
                oldValue: item[field]
            };

            // 阻止事件冒泡，防止触发行选择
            if (event) {
                event.stopPropagation();
            }
        },

        // 保存编辑
        saveEdit() {
            if (!this.editingCell.item) return;

            const item = this.editingCell.item;
            const field = this.editingCell.field;
            const oldValue = this.editingCell.oldValue;
            const newValue = this.editingCell.value;

            // 只有当值真正变化时才记录编辑
            if (oldValue !== newValue) {
                // 更新数据
                item[field] = newValue;

                // 将编辑后的item添加到editedItems列表（确保不重复）
                const existingIndex = this.editedItems.findIndex(editedItem => editedItem.serialNumber === item.serialNumber);
                if (existingIndex === -1) {
                    // 如果不存在，添加到列表
                    this.editedItems.push(item);
                } else {
                    // 如果已存在，更新对应项
                    this.editedItems[existingIndex] = item;
                }

                // 如果编辑的是f1或f2字段，同步更新子项的cf1和cf2
                if ((field === 'f1' || field === 'f2') && item.childs && Array.isArray(item.childs) && item.childs.length > 0) {
                    item.childs.forEach(child => {
                        // 根据字段名称更新对应的子项字段
                        if (field === 'f1') {
                            child.cf1 = item.f1;
                        } else if (field === 'f2') {
                            child.cf2 = item.f2;
                        }
                    });
                }
            }

            // 清除编辑状态
            this.editingCell = {
                item: null,
                field: null,
                value: null,
                oldValue: null
            };
        },

        // 取消编辑
        cancelEdit() {
            if (!this.editingCell.item) return;

            // 恢复原值
            this.editingCell.item[this.editingCell.field] = this.editingCell.oldValue;

            // 清除编辑状态
            this.editingCell = {
                item: null,
                field: null,
                value: null,
                oldValue: null
            };
        },

        // 检查字段是否可编辑
        isFieldEditable(field) {
            const config = this.tableConfig.find(col => col.field === field);
            return config && config.editable;
        },

        // 获取字段配置
        getFieldConfig(field) {
            return this.tableConfig.find(col => col.field === field) || {};
        },

        // 获取已编辑的行数
        getEditedRowsCount() {
            return this.editedItems.length;
        },

        // 检查行是否被编辑过
        isRowEdited(itemSerialNumber) {
            return this.editedItems.some(item => item.serialNumber === itemSerialNumber);
        },

        // 获取所有已编辑的数据（用于提交给服务端）
        getEditedItemsForSubmit() {
            return [...this.editedItems]; // 返回副本，防止外部修改
        },

        // 清空已编辑数据
        clearEditedItems() {
            this.editedItems = [];
        },
    },
}); 